home *** CD-ROM | disk | FTP | other *** search
/ ASME's Mechanical Engine…ing Toolkit 1997 December / ASME's Mechanical Engineering Toolkit 1997 December.iso / c_lang / tccurses.lzh / UPDATE.C < prev    next >
C/C++ Source or Header  |  1987-09-07  |  8KB  |  243 lines
  1. /****************************************************************/
  2. /* Doupdate() routine of the PCcurses package            */
  3. /*                                */
  4. /****************************************************************/
  5. /* This version of curses is based on ncurses, a curses version    */
  6. /* originally written by Pavel Curtis at Cornell University.    */
  7. /* I have made substantial changes to make it run on IBM PC's,    */
  8. /* and therefore consider myself free to make it public domain.    */
  9. /*        Bjorn Larsson (...mcvax!enea!infovax!bl)    */
  10. /****************************************************************/
  11. /* 1.0:    Release:                    870515    */
  12. /****************************************************************/
  13.  
  14. #include <curses.h>
  15. #include <curspriv.h>
  16.  
  17. static void clrupdate();        /* fwd declaration */
  18. static bool transformline();
  19. static void clearscreen();
  20. static void gotoxy();
  21. static void Putchar();
  22.  
  23. static WINDOW    *twin;            /* used by many routines */
  24.  
  25. static    char     atrtab[64] =        /* attribute encoding table. */
  26.  {                    /* feel free to edit if your */
  27.   7,        /* NORMAL (0) */        /* display board supports all */
  28.   0x87,        /* BLINK */            /* possible combinations */
  29.   0,        /* BLANK */
  30.   0,        /* BLINK & BLANK */
  31.   0xf,        /* BOLD */
  32.   0x8f,        /* BOLD & BLINK */
  33.   0,        /* BOLD & BLANK */
  34.   0,        /* BOLD & BLINK & BLANK */
  35.   0x70,        /* REVERSE (8) */
  36.   0xf0,        /* REVERSE & BLINK */
  37.   0,        /* REVERSE & BLANK */
  38.   0,        /* REVERSE & BLINK & BLANK */
  39.   0x78,        /* REVERSE & BOLD */
  40.   0xf8,        /* REVERSE & BOLD & BLINK */
  41.   0,        /* REVERSE & BOLD & BLANK */
  42.   0,        /* REVERSE & BOLD & BLINK & BLANK */
  43.   0xf,        /* STANDOUT (10) */
  44.   0x8f,        /* STANDOUT & BLINK */
  45.   0,        /* STANDOUT & BLANK */
  46.   0,        /* STANDOUT & BLINK & BLANK */
  47.   0xf,        /* STANDOUT & BOLD */
  48.   0x8f,        /* STANDOUT & BOLD & BLINK */
  49.   0,        /* STANDOUT & BOLD & BLANK */
  50.   0,        /* STANDOUT & BOLD & BLINK & BLANK */
  51.   0x70,        /* STANDOUT & REVERSE (18) */
  52.   0xf0,        /* STANDOUT & REVERSE & BLINK */
  53.   0,        /* STANDOUT & REVERSE & BLANK */
  54.   0,        /* STANDOUT & REVERSE & BLINK & BLANK */
  55.   0x70,        /* STANDOUT & REVERSE & BOLD */
  56.   0xf0,        /* STANDOUT & REVERSE & BOLD & BLINK */
  57.   0,        /* STANDOUT & REVERSE & BOLD & BLANK */
  58.   0,        /* STANDOUT & REVERSE & BOLD & BLINK & BLANK */
  59.   1,        /* UNDERLINE (20) */
  60.   0x81,        /* UNDERLINE & BLINK */
  61.   0,        /* UNDERLINE & BLANK */
  62.   0,        /* UNDERLINE & BLINK & BLANK */
  63.   9,        /* UNDERLINE & BOLD */
  64.   0x89,        /* UNDERLINE & BOLD & BLINK */
  65.   0,        /* UNDERLINE & BOLD & BLANK */
  66.   0,        /* UNDERLINE & BOLD & BLINK & BLANK */
  67.   0x70,        /* UNDERLINE & REVERSE (28) */
  68.   0xf0,        /* UNDERLINE & REVERSE & BLINK */
  69.   0,        /* UNDERLINE & REVERSE & BLANK */
  70.   0,        /* UNDERLINE & REVERSE & BLINK & BLANK */
  71.   0x79,        /* UNDERLINE & REVERSE & BOLD */
  72.   0xf9,     /* UNDERLINE & REVERSE & BOLD & BLINK */
  73.   0,        /* UNDERLINE & REVERSE & BOLD & BLANK */
  74.   0,        /* UNDERLINE & REVERSE & BOLD & BLINK & BLANK */
  75.   9,        /* UNDERLINE & STANDOUT (30) */
  76.   0x89,        /* UNDERLINE & STANDOUT & BLINK */
  77.   0,        /* UNDERLINE & STANDOUT & BLANK */
  78.   0,        /* UNDERLINE & STANDOUT & BLINK & BLANK */
  79.   9,        /* UNDERLINE & STANDOUT & BOLD */
  80.   0x89,        /* UNDERLINE & STANDOUT & BOLD & BLINK */
  81.   0,        /* UNDERLINE & STANDOUT & BOLD & BLANK */
  82.   0,        /* UNDERLINE & STANDOUT & BOLD & BLINK & BLANK */
  83.   0x70,        /* UNDERLINE & STANDOUT & REVERSE (38) */
  84.   0xf0,        /* UNDERLINE & STANDOUT & REVERSE & BLINK */
  85.   0,        /* UNDERLINE & STANDOUT & REVERSE & BLANK */
  86.   0,        /* UNDERLINE & STANDOUT & REVERSE & BLINK & BLANK */
  87.   0x70,        /* UNDERLINE & STANDOUT & REVERSE & BOLD */
  88.   0xf0,        /* UNDERLINE & STANDOUT & REVERSE & BOLD & BLINK */
  89.   0,        /* UNDERLINE & STANDOUT & REVERSE & BOLD & BLANK */
  90.   0,        /* UNDERLINE & STANDOUT & REVERSE & BOLD & BLINK & BLANK */
  91.   };
  92.  
  93. /****************************************************************/
  94. /* Doupdate() updates the physical screen to look like _curs-   */
  95. /* var.tmpwin if curscr is not 'Clear-marked'. Otherwise it    */
  96. /* updates the screen to look like curscr.            */
  97. /****************************************************************/
  98.  
  99. void doupdate()
  100.   {
  101.   register int         i;
  102.  
  103.   twin   = _cursvar.tmpwin;
  104.   if (curscr->_clear)
  105.     clrupdate(curscr);
  106.   else
  107.     {
  108.     if (twin->_clear)
  109.       clrupdate(twin);
  110.     else
  111.       {
  112.       for (i=0; i < LINES; i++)
  113.     if (twin->_minchng[i] != _NO_CHANGE)
  114.       if (transformline(i))
  115.         break;
  116.       } /* else */
  117.     } /* else */
  118.   curscr->_curx = twin->_curx;
  119.   curscr->_cury = twin->_cury;
  120.   gotoxy(curscr->_cury, curscr->_curx);
  121.   } /* doupdate */
  122.  
  123. /****************************************************************/
  124. /* Clrupdate(scr) updates the screen by clearing it and then    */
  125. /* redraw it in it's entirety. If _cursvar.refrbrk is TRUE, and    */
  126. /* there is pending input characters, the update will be pre-    */
  127. /* maturely terminated.                        */
  128. /****************************************************************/
  129.  
  130. static void clrupdate(scr)
  131.   WINDOW    *scr;
  132.   {
  133.   register int        *src;
  134.   register int        *dst;
  135.   register int         i;
  136.   register int         j;
  137.   static   WINDOW    *w;
  138.  
  139.   w = curscr;
  140.   
  141.   if (scr != w)                /* copy scr to curscr */
  142.     {
  143.     for (i=0; i < LINES; i++)
  144.       {
  145.       src = scr->_line[i];
  146.       dst = w->_line[i];
  147.       for (j=0; j < COLS; j++)
  148.     *dst++ = *src++;
  149.       } /* for */
  150.     } /* if */
  151.   clearscreen();            /* clear physical screen */
  152.   scr->_clear = FALSE;
  153.   for (i=0; i < LINES; i++)        /* update physical screen */
  154.     {
  155.     src = w->_line[i];
  156.     for(j=0; j < COLS; j++)
  157.       {
  158.       if (*src != (' ' | ATR_NRM))
  159.     {
  160.     gotoxy(i,j);
  161.     Putchar(*src);
  162.     } /* if */
  163.       src++;
  164.       } /* for */
  165.     if(_cursvar.refrbrk && _cursespendch())
  166.       return;
  167.     } /* for */
  168.   } /* clrupdate */
  169.  
  170. /****************************************************************/
  171. /* Transformline() updates the given physical line to look    */
  172. /* like the corresponding line in _cursvar.tmpwin. Transform-    */
  173. /* returns 1 if premature refresh end is allowed, and there is    */
  174. /* an input character pending.                    */
  175. /****************************************************************/
  176.  
  177. static bool transformline(lineno)
  178.   register int    lineno;
  179.   {
  180.   register int        *dstp;
  181.   register int        *srcp;
  182.   static   int         x;
  183.   static   int         endx;
  184.  
  185.   x    = twin->_minchng[lineno];
  186.   endx = twin->_maxchng[lineno];
  187.   dstp = curscr->_line[lineno] + x;
  188.   srcp = twin->_line[lineno] + x;
  189.   
  190.   for( ; x <= endx; x++)
  191.     {
  192.     if(*dstp != *srcp)
  193.       {
  194.       gotoxy(lineno,x);
  195.       Putchar(*srcp);
  196.       } /* if */
  197.     *dstp++ = *srcp++;
  198.     } /* for */
  199.   twin->_minchng[lineno] = _NO_CHANGE;
  200.   twin->_maxchng[lineno] = _NO_CHANGE;
  201.   return (_cursvar.refrbrk && _cursespendch());
  202.   } /* transformline */
  203.  
  204. /****************************************************************/
  205. /* Clearscreen() clears the physical screen and puts the cursor    */
  206. /* in the home position.                    */
  207. /****************************************************************/
  208.  
  209. static void clearscreen()
  210.   {
  211.   _cursesscroll(0,0,LINES-1,COLS-1,0,atrtab[0]);
  212.   gotoxy(0,0);
  213.   } /* clearscreen */
  214.  
  215. /****************************************************************/
  216. /* Gotoxy() moves the physical cursor to the desired address on    */
  217. /* the screen. We don't optimize here - on a PC, it takes more    */
  218. /* time to optimize than to do things directly.            */
  219. /****************************************************************/
  220.  
  221. static void gotoxy(row,col)
  222.   int row, col;
  223.   {
  224.   if((_cursvar.cursrow == row) && (_cursvar.curscol == col))
  225.     return;
  226.   _cursescursor(0,row,col);
  227.   _cursvar.cursrow = row;
  228.   _cursvar.curscol = col;
  229.   } /* gotoxy */
  230.  
  231. /****************************************************************/
  232. /* Putchar() writes a character, with attributes, to the physi-    */
  233. /* cal screen, but avoids writing to the lower right screen    */
  234. /* position.                            */
  235. /****************************************************************/
  236.  
  237. static void Putchar(ch)
  238.   int ch;
  239.   {
  240.   if ((_cursvar.cursrow < LINES) || (_cursvar.curscol < COLS))
  241.     _cursescattr(0,ch,atrtab[(ch >> 8) & 0x3f],1);
  242.   } /* Putchar */
  243.